// 引入HTTP请求工具
const http = require('../../../utils/https.js');

// 注意：当前使用模拟数据模式进行前端测试
// 将 useMockData 设置为 false 即可使用真实接口
// 需要确保后端接口已准备好：
// - 月卡创建：POST /monthlyCard/monthlyCard
// - 月卡查询：GET /monthlyCard/monthlyCard/{vehicleId}

Page({
  data: {
    // 车辆信息（从车辆详情页传递过来）
    vehicleInfo: null,
    vehicleId: '',
    plateNumber: '',
    brand: '',
    model: '',
    color: '',
    imageUrl: '',
    
    // 月卡信息
    startDate: '',    // 生效日期
    expiryDate: '',   // 到期时间（有效期至）
    maxEndDate: '',   // 最大可选到期时间
    remark: '',       // 备注
    cardDays: 0,      // 月卡天数
    totalAmount: 0,   // 费用合计
    
    // 月卡状态
    hasMonthlyCard: false,  // 是否已有月卡
    monthlyCardInfo: null,  // 月卡详细信息
    
    // 加载状态
    loading: false,
    queryLoading: false,    // 查询月卡状态时的加载状态
    initialLoading: true    // 页面初始加载状态
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('月卡页面加载，参数:', options);
    
    // 自动设置生效日期为当前时间
    const now = new Date();
    const currentDate = this.formatDate(now);
    
    // 设置最大可选到期时间（当前日期后1年）
    const maxEndDate = new Date(now.getFullYear() + 1, now.getMonth(), now.getDate());
    const maxEndDateStr = this.formatDate(maxEndDate);
    
    this.setData({
      startDate: currentDate,
      maxEndDate: maxEndDateStr,
      initialLoading: true
    });
    
    if (options.vehicleData) {
      try {
        // 解码传递过来的车辆数据
        const vehicleData = JSON.parse(decodeURIComponent(options.vehicleData));
        console.log('接收到的车辆数据:', vehicleData);
        
        // 设置车辆信息到页面数据
        this.setData({
          vehicleInfo: vehicleData,
          vehicleId: vehicleData.vehicleId || '',
          plateNumber: vehicleData.plateNumber || '',
          brand: vehicleData.brand || '',
          model: vehicleData.model || '',
          color: vehicleData.color || '',
          imageUrl: vehicleData.imageUrl || ''
        });
        
        console.log('车辆信息设置完成:', this.data);
        
        // 检查该车辆是否已有月卡
        this.checkMonthlyCardStatus();
        
      } catch (error) {
        console.error('解析车辆数据失败:', error);
        this.setData({ initialLoading: false });
        wx.showToast({
          title: '车辆信息获取失败',
          icon: 'none'
        });
      }
    } else {
      console.log('未接收到车辆数据');
      this.setData({ initialLoading: false });
      wx.showToast({
        title: '未获取到车辆信息',
        icon: 'none'
      });
    }
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('页面显示，检查月卡状态');
    // 每次页面显示时都检查月卡状态
    if (this.data.vehicleId && this.data.plateNumber) {
      this.checkMonthlyCardStatus();
    }
  },

  // 手动刷新月卡状态
  refreshMonthlyCardStatus() {
    console.log('手动刷新月卡状态');
    this.checkMonthlyCardStatus();
  },

  // 检查月卡状态 - 优化后的查询逻辑
  checkMonthlyCardStatus() {
    const { vehicleId, plateNumber } = this.data;
    if (!vehicleId || !plateNumber) {
      console.log('车辆ID或车牌号为空，无法查询月卡状态');
      console.log('vehicleId:', vehicleId);
      console.log('plateNumber:', plateNumber);
      this.setData({ 
        initialLoading: false,
        queryLoading: false 
      });
      return;
    }
    
    console.log('开始检查月卡状态...');
    console.log('车辆ID:', vehicleId);
    console.log('车牌号:', plateNumber);
    
    // 显示查询加载状态
    this.setData({ 
      queryLoading: true,
      initialLoading: false 
    });
    
    // 优先使用车辆ID查询月卡信息（更准确）
    this.queryMonthlyCardByVehicleId(vehicleId);
  },

  // 根据车辆ID查询月卡信息
  queryMonthlyCardByVehicleId(vehicleId) {
    console.log('根据车辆ID查询月卡信息:', vehicleId);
    
    // 开发测试：使用模拟数据（生产环境请删除）
    const useMockData = true; // 设置为false使用真实接口
    
    if (useMockData) {
      console.log('使用模拟数据测试月卡查询');
      setTimeout(() => {
        // 模拟接口延迟
        const mockResponse = this.getMockMonthlyCardData(vehicleId);
        this.handleMonthlyCardQuerySuccess(mockResponse);
      }, 1000);
      return;
    }
    
    // 调用接口查询月卡状态
    http.get(`monthlyCard/monthlyCard/${vehicleId}`)
      .then(res => {
        console.log('月卡状态查询成功，完整响应:', res);
        console.log('响应状态码:', res.code);
        console.log('响应数据:', res.data);
        
        this.handleMonthlyCardQuerySuccess(res);
      })
      .catch(err => {
        console.error('根据车辆ID查询月卡状态失败:', err);
        // 如果根据车辆ID查询失败，尝试使用车牌号查询
        this.queryMonthlyCardByPlateNumber();
      });
  },

  // 根据车牌号查询月卡信息（备用方案）
  queryMonthlyCardByPlateNumber() {
    const { plateNumber } = this.data;
    console.log('根据车牌号查询月卡信息:', plateNumber);
    
    // 开发测试：使用模拟数据（生产环境请删除）
    const useMockData = true; // 设置为false使用真实接口
    
    if (useMockData) {
      console.log('使用模拟数据测试月卡查询（车牌号）');
      setTimeout(() => {
        // 模拟接口延迟
        const mockResponse = this.getMockMonthlyCardData(null, plateNumber);
        this.handleMonthlyCardQuerySuccess(mockResponse);
      }, 800);
      return;
    }
    
    http.get('monthlyCard/getMonthlyCard', {
      plateNumber: plateNumber
    })
      .then(res => {
        console.log('根据车牌号查询月卡状态成功:', res);
        this.handleMonthlyCardQuerySuccess(res);
      })
      .catch(err => {
        console.error('根据车牌号查询月卡状态也失败:', err);
        this.handleMonthlyCardQueryFailure(err);
      });
  },

  // 获取模拟月卡数据（开发测试用）
  getMockMonthlyCardData(vehicleId, plateNumber) {
    const { plateNumber: currentPlate } = this.data;
    const targetPlate = plateNumber || currentPlate;
    
    // 模拟数据：根据车牌号判断是否有月卡
    // 这里可以根据需要调整逻辑
    const hasCard = targetPlate && (targetPlate.includes('888') || targetPlate.includes('666'));
    
    if (hasCard) {
      // 有月卡的情况
      const now = new Date();
      const startDate = new Date(now.getFullYear(), now.getMonth(), 1); // 本月1号
      const expiryDate = new Date(now.getFullYear(), now.getMonth() + 1, 0); // 下月最后一天
      
      return {
        code: 200,
        data: {
          id: 'mock_' + Date.now(),
          vehicleId: vehicleId || 'mock_vehicle_001',
          plateNumber: targetPlate,
          startDate: this.formatDate(startDate),
          expiryDate: this.formatDate(expiryDate),
          cardDays: 30,
          fee: 300.00,
          totalAmount: 300.00,
          remark: '模拟月卡数据',
          cardStatus: 1,
          createTime: new Date().toISOString()
        }
      };
    } else {
      // 无月卡的情况
      return {
        code: 200,
        data: null
      };
    }
  },

  // 处理月卡查询成功的逻辑
  handleMonthlyCardQuerySuccess(res) {
    this.setData({ queryLoading: false });
    
    if (res.code === 200 && res.data) {
      let monthlyCardData = null;
      
      // 处理不同的接口返回格式
      if (Array.isArray(res.data) && res.data.length > 0) {
        // 如果是数组格式，取最新的月卡
        monthlyCardData = res.data[0];
      } else if (res.data && typeof res.data === 'object') {
        // 如果是对象格式，直接使用
        monthlyCardData = res.data;
      }
      
      if (monthlyCardData) {
        console.log('找到月卡信息:', monthlyCardData);
        
        // 处理日期格式
        const startDate = monthlyCardData.startDate || monthlyCardData.startTime || this.data.startDate;
        const expiryDate = monthlyCardData.expiryDate || monthlyCardData.endTime || '';
        
        this.setData({
          hasMonthlyCard: true,
          monthlyCardInfo: monthlyCardData,
          startDate: startDate,
          expiryDate: expiryDate,
          cardDays: monthlyCardData.cardDays || monthlyCardData.days || 0,
          totalAmount: monthlyCardData.fee || monthlyCardData.totalAmount || monthlyCardData.amount || 0,
          remark: monthlyCardData.remark || monthlyCardData.description || ''
        });
        
        console.log('月卡信息已加载到页面状态');
        console.log('当前页面状态:', this.data);
        
        wx.showToast({
          title: '月卡信息加载成功',
          icon: 'success',
          duration: 1500
        });
      } else {
        console.log('该车辆暂无月卡信息');
        this.setData({
          hasMonthlyCard: false,
          monthlyCardInfo: null
        });
      }
    } else {
      console.log('该车辆暂无月卡或查询结果为空');
      console.log('响应状态:', res.code);
      console.log('响应数据:', res.data);
      
      // 确保状态为无月卡
      this.setData({
        hasMonthlyCard: false,
        monthlyCardInfo: null
      });
    }
  },

  // 处理月卡查询失败的逻辑
  handleMonthlyCardQueryFailure(err) {
    console.error('查询月卡状态失败:', err);
    console.error('错误详情:', JSON.stringify(err, null, 2));
    
    this.setData({ 
      queryLoading: false,
      hasMonthlyCard: false,
      monthlyCardInfo: null
    });
    
    // 查询失败时，显示错误提示但不影响购买流程
    wx.showToast({
      title: '查询月卡状态失败',
      icon: 'none',
      duration: 2000
    });
  },

  // 格式化日期为 YYYY-MM-DD 格式
  formatDate(date) {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    return `${year}-${month}-${day}`;
  },

  // 计算两个日期之间的天数差
  calculateDays(startDate, endDate) {
    const start = new Date(startDate);
    const end = new Date(endDate);
    const timeDiff = end.getTime() - start.getTime();
    const daysDiff = Math.ceil(timeDiff / (1000 * 3600 * 24));
    return daysDiff;
  },

  // 计算费用
  calculateAmount(days) {
    return days * 10;
  },

  // 到期时间变化处理
  onEndDateChange(e) {
    const endDate = e.detail.value;
    console.log('选择的到期时间:', endDate);
    
    this.setData({ expiryDate: endDate });
    
    // 自动计算天数和金额
    const days = this.calculateDays(this.data.startDate, endDate);
    const amount = this.calculateAmount(days);
    
    this.setData({
      cardDays: days,
      totalAmount: amount
    });
    
    console.log('计算出的天数:', days, '金额:', amount);
  },

  // 持卡人姓名输入
  onNameInput(e) {
    // 可在此处理输入逻辑
  },

  // 手机号码输入
  onPhoneInput(e) {
    // 可在此处理输入逻辑
  },

  // 备注输入
  onRemarkInput(e) {
    this.setData({ remark: e.detail.value });
  },

  // 确认购买
  onConfirm() {
    const { vehicleId, plateNumber, startDate, expiryDate, remark, cardDays, totalAmount } = this.data;
    
    // 简单校验
    if (!vehicleId) {
      wx.showToast({ title: '车辆信息不完整', icon: 'none' });
      return;
    }
    
    if (!startDate || !expiryDate) {
      wx.showToast({ title: '请选择到期日期', icon: 'none' });
      return;
    }
    
    if (new Date(startDate) >= new Date(expiryDate)) {
      wx.showToast({ title: '到期日期必须晚于生效日期', icon: 'none' });
      return;
    }
    
    if (cardDays <= 0) {
      wx.showToast({ title: '月卡天数必须大于0', icon: 'none' });
      return;
    }

    // 显示加载状态
    this.setData({ loading: true });
    wx.showLoading({ title: '正在购买...' });

    // 准备请求数据
    const requestData = {
      vehicleId: vehicleId,
      plateNumber: plateNumber,
      cardStatus: 0,
      startDate: startDate,
      expiryDate: expiryDate,
      cardDays: cardDays,
      totalAmount: totalAmount,
      fee: totalAmount, // 添加fee字段，对应数据库中的费用字段
      remark: remark || ''
    };

    console.log('准备购买月卡，请求数据:', requestData);
    
    // 验证请求数据完整性
    const requiredFields = ['vehicleId', 'plateNumber', 'startDate', 'expiryDate', 'cardDays', 'totalAmount'];
    const missingFields = requiredFields.filter(field => !requestData[field] && requestData[field] !== 0);
    
    if (missingFields.length > 0) {
      wx.showModal({
        title: '数据不完整',
        content: `缺少必填字段: ${missingFields.join(', ')}`,
        showCancel: false,
        confirmText: '确定'
      });
      return;
    }
    
    // 验证数据格式
    if (cardDays <= 0) {
      wx.showModal({
        title: '数据错误',
        content: '月卡天数必须大于0',
        showCancel: false,
        confirmText: '确定'
      });
      return;
    }
    
    if (totalAmount <= 0) {
      wx.showModal({
        title: '数据错误',
        content: '月卡金额必须大于0',
        showCancel: false,
        confirmText: '确定'
      });
      return;
    }
    
    console.log('数据验证通过，开始调用接口...');
    
    // 临时使用模拟数据测试前端流程（后端接口准备好后可以删除）
    const useMockData = false; // 设置为false使用真实接口
    
    if (useMockData) {
      // 模拟接口调用成功
      console.log('使用模拟数据测试');
      setTimeout(() => {
        wx.hideLoading();
        
        // 模拟接口返回数据
        const mockResponse = {
          code: 200,
          data: {
            id: 'mock_' + Date.now(),
            message: '月卡创建成功'
          }
        };
        
        this.handleMonthlyCardSuccess(mockResponse, requestData);
      }, 1000);
    } else {
      // 调用真实接口新增月卡
      http.post('monthlyCard/monthlyCard', requestData)
        .then(res => {
          console.log('月卡购买成功，完整响应:', res);
          console.log('响应状态码:', res.code);
          console.log('响应数据:', res.data);
          
          // 检查响应状态
          if (res.code !== 200) {
            throw new Error(`接口返回错误: ${res.msg || res.message || '未知错误'}`);
          }
          
          // 检查是否有返回的ID
          if (!res.data || !res.data.id) {
            console.warn('接口返回成功但缺少ID字段:', res);
          }
          
          wx.hideLoading();
          this.handleMonthlyCardSuccess(res, requestData);
        })
        .catch(err => {
          console.error('月卡购买失败，详细错误:', err);
          console.error('错误类型:', typeof err);
          console.error('错误对象:', JSON.stringify(err, null, 2));
          
          wx.hideLoading();
          
          // 显示详细的错误信息
          let errorMsg = '购买失败，请重试';
          
          if (typeof err === 'string') {
            errorMsg = err;
          } else if (err && err.message) {
            errorMsg = err.message;
          } else if (err && err.msg) {
            errorMsg = err.msg;
          } else if (err && err.error) {
            errorMsg = err.error;
          }
          
          // 显示错误详情
          wx.showModal({
            title: '月卡创建失败',
            content: `错误信息: ${errorMsg}\n\n请检查网络连接或联系客服`,
            showCancel: false,
            confirmText: '确定'
          });
          
          console.error('最终显示的错误信息:', errorMsg);
        })
        .finally(() => {
          this.setData({ loading: false });
        });
    }
  },

  // 处理月卡创建成功的逻辑
  handleMonthlyCardSuccess(res, requestData) {
    const { vehicleId, plateNumber, startDate, expiryDate, cardDays, totalAmount, remark } = requestData;
    
    // 将月卡信息存储到本地，供支付页面使用
    const monthlyCardData = {
      id: res.data?.id || res.id, // 根据实际接口返回结构调整
      type: 'monthlyCard',
      vehicleId: vehicleId,
      plateNumber: plateNumber,
      startDate: startDate,
      expiryDate: expiryDate,
      cardDays: cardDays,
      totalAmount: totalAmount,
      remark: remark || '',
      createTime: new Date().toISOString()
    };
    
    wx.setStorageSync('currentMonthlyCardOrder', monthlyCardData);
    
    // 更新页面状态，显示月卡信息
    this.setData({
      hasMonthlyCard: true,
      monthlyCardInfo: monthlyCardData
    });
    
    wx.showToast({ 
      title: '月卡创建成功，即将跳转支付', 
      icon: 'success',
      duration: 1500
    });
    
    // 延迟跳转到支付页面
    setTimeout(() => {
      wx.navigateTo({
        url: `/service/pages/paycar/paycar?amount=${totalAmount}&orderType=monthlyCard`
      });
    }, 1500);
  },

  // 续费月卡
  onRenewCard() {
    console.log('续费月卡');
    // 重置月卡状态，显示购买表单
    this.setData({
      hasMonthlyCard: false,
      monthlyCardInfo: null,
      expiryDate: '',
      cardDays: 0,
      totalAmount: 0,
      remark: ''
    });
    
    wx.showToast({
      title: '请选择新的到期时间',
      icon: 'none'
    });
  },

  // 查看月卡详情
  onViewDetail() {
    console.log('查看月卡详情');
    const { monthlyCardInfo } = this.data;
    
    if (monthlyCardInfo) {
      // 可以将月卡详情传递给详情页面
      const detailData = encodeURIComponent(JSON.stringify(monthlyCardInfo));
      wx.navigateTo({
        url: `/mine/pages/monthly-card-detail/monthly-card-detail?monthlyCardData=${detailData}`
      });
    }
  }
}); 